package com.endoc.lib.s04

import java.util.concurrent.locks.ReentrantLock


//kt高阶函数


fun main() {
    /*
    * sumBy高阶函数
    * 参数为函数,函数功能是将每个字符变成int类型,转换规则自定义,此处直接it.toInt()
    * */
    val sumBy = "sumBy".sumBy {
        it.toInt()//设置转换规则
    }
    println(sumBy)



    /*
    此lock无法直接用,具体原因不明
    var  reentrantLock =ReentrantLock()

    lock(reentrantLock){
        println("lock关键字测试")

    }*/

    /*
    * run高阶,返回值为函数参数的返回值
    * */
    val run = run {
        var run ="1234"
        when(run){
           "1234"-> "run高阶函数测试1"
        }
        "run高阶函数测试2"
    }
    println(run)

    /*
    * T.run高阶,返回值为T本身,即调用者
    * */
    var t_run ="T_run"
    t_run.run {
        "t_run高阶函数测试"
    }
    println(t_run)

    /*
    * with高阶函数,返回值为函数参数的返回值
    * */
    var with="with"
    val with1 = with(with) {
        println(with)
        "with的高阶函数"
    }
    println(with1)

    /*
    * apply高阶函数,返回值为调用者本身,有点像构建者模式
    * */
    var apply="apply"
    val apply1 = apply.apply {
        println(this)
    }
    println("apply高阶函数$apply1")

    /*
    *also高阶函数,返回调用者本身
    * */

    var t_also ="T_also"
    val also = t_also.also {
        println(it)
    }
    println("also高阶函数$also")



    //https://www.freesion.com/article/8865126951/
    val takeIf = "takeIf"

    val result = takeIf.takeIf {
        it.startsWith("ko")
    }

    println("result = $result")


}